#include "wnd_api.h"



#define MINI_RET_BOOL(RET)		(return ((RET == TRUE) ? 0 : -1))




/*!
 * 创建一个主窗口 创建后需要 MINI_INTF_StartMainWndProc 来获取主窗口的消息，获取的消息会发往回调函数
 * @param hHosting 主窗口的依赖窗口 可以填 HWND_DESKTOP
 * @return  返回主窗口的id 0 为失败
 * @param MainWndMsgProc 窗口的消息回调函数
 * @param s32BkColor 窗口的背景颜色 COLOR_black 为黑色
 * @param s32CmdShow 是否显示窗口 SW_SHOWNORMAL 显示窗口 SW_HIDE 隐藏窗口
 * @param s32WndHeight 窗口的高度
 * @param s32WndWidth 窗口的宽度
 * @param s32WndX 窗口X坐标
 * @param s32WndY 窗口Y坐标
 * @param u64AddData 窗口附加数据，会和窗口ID绑定，通过函数 MINI_INTF_GetAddDate 可以获取到
 * @param u64ExStyle 窗口的外部风格 不知道可以填 WS_EX_NONE
 * @param u64Style 窗口的风格 例如 WS_VISIBLE | WS_BORDER
 * @see MINI_INTF_GetAddDate MINI_INTF_StartMainWndProc
 */
unsigned int MINI_INTF_CreateMainWnd(unsigned long u64Style, unsigned long u64ExStyle,
									int (*MainWndMsgProc)(unsigned int u32Wnd, int s32Message, unsigned int u32Param, unsigned long u64Param),
									int s32WndX, int s32WndY, int s32WndWidth, int s32WndHeight,
									//UI_COLOUR_E enBkColor,
									int s32BkColor,
									unsigned long u64AddData,
									HWND  hHosting,
									int s32CmdShow)
{
	BOOL u8Ret;
	unsigned int u32MainWnd;
	MAINWINCREATE stCreateInfo;

	if(MainWndMsgProc == NULL) {
		QLOG(ERR, "主窗口的回调函数不能为空\n");
		return 0;
	}
	if(s32WndWidth == 0 || s32WndHeight == 0) {
		QLOG(ERR, "主窗口的长宽必须大于0 s32WndWidth[%d] s32WndHeight[%d]\n", s32WndWidth, s32WndHeight);
		return 0;
	}

	stCreateInfo.dwStyle = u64Style;
	stCreateInfo.dwExStyle = u64ExStyle;
	stCreateInfo.spCaption = "";
	stCreateInfo.hMenu = 0;
	stCreateInfo.hCursor = GetSystemCursor(0);
	stCreateInfo.hIcon = 0;
	stCreateInfo.MainWindowProc = MainWndMsgProc;
	stCreateInfo.lx = s32WndX;
	stCreateInfo.ty = s32WndY;
	stCreateInfo.rx = s32WndWidth;
	stCreateInfo.by = s32WndHeight;
	stCreateInfo.iBkColor = s32BkColor;
	stCreateInfo.dwAddData = u64AddData;
	stCreateInfo.hHosting = hHosting;

	//QLOG(TDBG, "%d %d\n", stCreateInfo.iBkColor, COLOR_darkgreen);
	u32MainWnd = CreateMainWindow(&stCreateInfo);
	if (u32MainWnd == HWND_INVALID) {
		QLOG(ERR, "主界面创建失败\n");
		return -1;
	}




	u8Ret = ShowWindow(u32MainWnd, s32CmdShow);
	if(FALSE == u8Ret) {
		QLOG(ERR, "MINI_API_ShowOrHideWindow failed\n");
		return -1;
	} else if(TRUE == u8Ret) {
		QLOG(TDBG, "成功显示窗口\n");
	}

	/* 刷新窗口*/
	UpdateWindow(u32MainWnd, TRUE);

	return u32MainWnd;
}




unsigned int MINI_INTF_CreateWnd(char *ps8Class, char *pstStr, DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{

	unsigned int u32WndId;
	u32WndId = CreateWindow(ps8Class,
							pstStr,
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);
	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}
	return u32WndId;
}


/*!
 * 开始获取主窗口的消息
 * @param u32MainWnd 主窗口的id
 * @see
 */
void MINI_INTF_StartMainWndProc(unsigned int u32MainWnd)
{
	MSG stMsg;
	while(GetMessage(&stMsg, u32MainWnd)) {

		TranslateMessage (&stMsg);
		DispatchMessage (&stMsg);

	}
	QLOG(TDBG, "退出窗口\n");

	MainWindowThreadCleanup(u32MainWnd);

}


/*!
 * 销毁一个主窗口
 * @return  0 成功 -1 失败
 * @param u32MainWnd 要销毁的窗口id
 * @see
 */
int MINI_INTF_DestroyMainWnd(unsigned int u32MainWnd)
{
	BOOL u8Ret = FALSE;


	u8Ret = DestroyMainWindow(u32MainWnd);


	return (u8Ret == TRUE ? 0 : -1);

}

int MINI_INTF_DestroyWnd(unsigned int u32MainWnd)
{
	BOOL u8Ret = FALSE;


	u8Ret = DestroyWindow(u32MainWnd);

	return (u8Ret == TRUE ? 0 : -1);

}


/*!
 * 获取窗口附加的数据地址
 * @return  获取到的附加数据的地址
 * @param u32Wnd 要获取的窗口的id
 * @see
 */
unsigned long MINI_INTF_GetAddDate(unsigned int u32Wnd)
{
	return GetWindowAdditionalData(u32Wnd);

}

/*!
 * 窗口通用函数 移动一个窗口的位置
 * @return  0 成功 -1 失败
 * @param s32WndHeight 窗口的高度
 * @param s32WndWidth 窗口的宽度
 * @param s32WndX 窗口的X坐标
 * @param s32WndY 窗口的Y坐标
 * @param u32Wnd 窗口的的窗口ID
 * @see
 */
int MINI_INTF_MoveWnd(unsigned int u32Wnd, int s32WndX, int s32WndY, int s32WndWidth, int s32WndHeight)
{
	BOOL u8Ret = FALSE;

	u8Ret = MoveWindow(u32Wnd, s32WndX, s32WndY, s32WndWidth, s32WndHeight, TRUE);

	return (u8Ret == TRUE ? 0 : -1);
}




/*!
 * 通用函数 显示或者隐藏一个窗口
 * @return 0 成功 -1 失败
 * @param s32CmdShow 显示或者隐藏 - SW_SHOW 显示窗口 SW_HIDE 隐藏窗口 SW_SHOWNORMAL 如果是主窗口则显示在最前面
 * @param u32Wnd 窗口的ID
 * @see
 */
int MINI_INTF_ShowWnd(HWND u32Wnd, int s32CmdShow)
{
	BOOL u8Ret = FALSE;
	u8Ret = ShowWindow(u32Wnd, s32CmdShow);

	return (u8Ret == TRUE ? 0 : -1);
}


/*!
 * 窗口通用函数 更新一个窗口
 * @return  无
 * @param u32Wnd 要刷新的窗口
 * @param u8Erase 是否刷新客户端 0不刷新 1刷新
 * @see
 */
void MINI_INTF_Update(HWND u32Wnd, BOOL u8Erase)
{
	UpdateWindow(u32Wnd, u8Erase);
}



/*!
 * 通用窗口函数 设置窗口的文字显示  可以用于编辑框、静态显示框等
 * @return 0 成功 -1 失败
 * @param ps8String 要显示的字符串
 * @param u32Wnd 要设置的窗口
 * @see
 */
int MINI_INTF_SetWindowText(HWND u32Wnd, char* ps8String)
{
	BOOL u8Ret = FALSE;
	u8Ret = SetWindowText(u32Wnd, ps8String);
	return (u8Ret == TRUE ? 0 : -1);
}


/*!
 * 通用窗口接口 获取窗口文本长度  可以用于编辑框、静态显示框等
 * @return  返回获取到的长度
 * @param u32WndId 窗口id
 * @see
 */
int MINI_INTF_GetWindowTextLength(unsigned int u32WndId)
{
	return GetWindowTextLength(u32WndId);
}



/*!
 * 通用接口 获取窗口的文本 可以用于编辑框、静态显示框等
 * @return  返回获取到的文本的长度
 * @param ps8Buf 获取到的文本存放在这里
 * @param s32BufLen 存放文本的缓冲大小
 * @param u32WndId 窗口id
 * @see
 */
int MINI_INTF_GetWindowText(unsigned int u32WndId, char* ps8Buf, int s32BufLen)
{
	return GetWindowText (u32WndId, ps8Buf, s32BufLen);
}



/*!
 * 窗口通用函数 设置窗口背景颜色
 * @return  返回之前的颜色
 * @param s32NewBkcolor 颜色值的颜色
 * @param u32Wnd 要设置哪个窗口
 * @see
 */
int MINI_INTF_SetWindowBkColor(HWND u32Wnd, int s32NewBkcolor)
{
	return SetWindowBkColor(u32Wnd, s32NewBkcolor);
}


/*!
 * 通用窗口函数 设置窗口的字体
 * @return 返回旧的字体
 * @param pstFont 要设置的字体 MINI_INTF_CreateLogFontUtf8 创建
 * @param u32Wnd 要设置的窗口
 * @see MINI_INTF_CreateLogFontUtf8
 */
LOGFONT* MINI_INTF_SetWindowFont(HWND u32Wnd, LOGFONT* pstFont)
{
	return SetWindowFont(u32Wnd, pstFont);
}






/*!
 * 创建一个 GB2312 的字体 如果需要改变风格，自己写个接口，因为风格太多了
 * @return  返回创建的字体
 * @param s32Size 字体的大小
 * @see MINI_INTF_DestroyLogFont
 */
LOGFONT* MINI_INTF_CreateLogFontGb2312(int s32Size)
{

	return CreateLogFont(NULL,"song","GB2312",FONT_WEIGHT_REGULAR,FONT_SLANT_ROMAN,FONT_FLIP_NIL,FONT_OTHER_AUTOSCALE,
								FONT_UNDERLINE_NONE,FONT_STRUCKOUT_NONE,s32Size,0);
}



/*!
 * 创建一个 utf8 的字体 如果需要改变风格，自己写个接口，因为风格太多了
 * @return  返回创建的字体
 * @param s32Size 字体的大小
 * @see MINI_INTF_DestroyLogFont
 */
LOGFONT* MINI_INTF_CreateLogFontUtf8(int s32Size)
{

	return CreateLogFont("ttf", "simhei", "UTF-8",FONT_WEIGHT_REGULAR, FONT_SLANT_ROMAN,FONT_FLIP_NIL, FONT_OTHER_NIL,
								FONT_UNDERLINE_NONE, FONT_STRUCKOUT_NONE, s32Size, 0);
}


/*!
 * 销毁一个字体
 * @param pstLogFont 要销毁的字体
 * @see MINI_INTF_CreateLogFontUtf8
 */
void MINI_INTF_DestroyLogFont(LOGFONT* pstLogFont)
{
	DestroyLogFont (pstLogFont);
}























/*!
 * 创建一个图标菜单的画布
 * @return  返回图标菜单的窗口id
 * @param u32Id 消息表示id
 * @param u32ParentWnd 父窗口 指出在那个主窗口上面创建图标菜单画布
 * @param u32WndHeight 画布的高
 * @param u32WndWidth 画布的宽
 * @param u32WndX 画布的x坐标
 * @param u32WndY 画布的y坐标
 * @param u64AddData 附加数据 通过 MINI_INTF_GetAddDate 可以获取到
 * @param u64Style 风格
 * @param WndMsgProc 消息回调函数
 * @see
 */
unsigned int MINI_INTF_CreateMenuWndByIcon(DWORD u64Style,
										unsigned int u32Id,
										unsigned int u32WndX, unsigned int u32WndY, unsigned int u32WndWidth, unsigned int u32WndHeight,
										HWND u32ParentWnd, DWORD u64AddData,
										void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;
	u32WndId = CreateWindow(CTRL_ICONVIEW, "",
												u64Style,
												u32Id,
												u32WndX,
												u32WndY,
												u32WndWidth,
												u32WndHeight,
												u32ParentWnd,
												u64AddData);
	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}

	return u32WndId;
}


/*!
 * 下载图标信息
 * @return 0成功
 * @param ps8MapPath 图标的路径
 * @param pstBitMap 图标信息会下载到这个结构体指针里面
 * @see
 */
int MINI_INTF_CreateBitMap(BITMAP *pstBitMap, char *ps8MapPath)
{
	LoadBitmap(HDC_SCREEN, pstBitMap, ps8MapPath);
	return 0;
}

/*!
 * 释放图片信息
 * @param pstBitMap  要释放图片信息句柄
 * @see
 */
void MINI_INTF_DestroyBitMap(BITMAP *pstBitMap)
{
	UnloadBitmap(pstBitMap);
}



/*!
 * 设置图标菜单在画布中的大小，在添加图标前设置，在画布中所有的图标的大小都一样
 * @return  消息处理程序的返回值
 * @param u23IconMenuWidth 图标的宽度
 * @param u32IconMenuHeight 图标的高度
 * @param u32WndId 窗口id，指出要设置的图标窗口
 * @see
 */
int MINI_INTF_MenuIconSetSize(unsigned int u32WndId, unsigned int u23IconMenuWidth, unsigned int u32IconMenuHeight)
{
	return SendMessage(u32WndId, IVM_SETITEMSIZE, u23IconMenuWidth, u32IconMenuHeight);
}

/*!
 * 添加一个图标菜单
 * @return 0 成功
 * @param ps8Name 图标菜单的名字，会显示在界面
 * @param pstIconMenu 位图的消息，需要通过 MINI_INTF_CreateBitMap 下载图标的消息
 * @param u32WndId 窗口id，指出添加在哪个窗口上面
 * @param s32Itm 插入图标的位置 非0右边 0,左边 (试验的结果就是这样)
 * @param u64AddData 附加数据
 * @see
 */
int MINI_INTF_AddIconToMenu(unsigned int u32WndId, int s32Itm, BITMAP *pstIconMenu, char *ps8Name,
										IVITEMINFO *pstIconItem, DWORD u64AddData)
{
	//IVITEMINFO stIconItem;

	//memset (&stIconItem, 0, sizeof(IVITEMINFO));
	pstIconItem->bmp = pstIconMenu;
	pstIconItem->nItem = 0;//s32Itm;
	//stIconItem.nItem = pstIconMenu[s32Num].s32Index;
	if(ps8Name == NULL || strlen(ps8Name) <= 0) {
		/* 图标的汉字名称，填NULL会消失，不填NULL只填数组虽然不会显示汉字但还是会占空间*/
		pstIconItem->label = NULL;
	} else {

		pstIconItem->label = ps8Name;
	}
	pstIconItem->addData = 0;//u64AddData;

	/* 添加按钮图标*/
	SendMessage (u32WndId, IVM_ADDITEM, 0, (LPARAM)pstIconItem);
	return 0;
}

/*!
 * 由图标的路径加载图标菜单按钮
 * @return 0 成功
 * @param ps8MapPath 图标的路径
 * @param ps8Name 图标的名字，不想显示名字就填NULL
 * @param pstBitMap 位图下载的结构体，销毁窗口前需要先释放这个位图消息
 * @param u32WndId 窗口结构体，在那个地方创建图标菜单
 * @param u64AddData 附加数据
 * @see
 */
int MINI_INTF_AddIconToMenuByPath(unsigned int u32WndId, int s32Itm,
							BITMAP *pstBitMap, char *ps8Name, char *ps8MapPath,
							IVITEMINFO *pstIconItem, DWORD u64AddData)
{
	MINI_INTF_CreateBitMap(pstBitMap, ps8MapPath);
	//MINI_INTF_AddIconToMenu(u32WndId, s32Itm, pstBitMap, ps8Name, u64AddData);
	MINI_INTF_AddIconToMenu(u32WndId, s32Itm, pstBitMap, ps8Name, pstIconItem, u64AddData);
	return 0;
}

/*!
 * 删除图标消息
 * @param pstBitMap 要删除的图片
 * @see
 */
void MINI_INTF_DelOneIconMenu(BITMAP *pstBitMap)
{
	MINI_INTF_DestroyBitMap(pstBitMap);
}

#if 0

/*!
 * 创建一个由图标组成的按钮菜单
 * @return  返回组成菜单的窗口id 0则为失败
 * @param pstIconMenu 窗口菜单的图标消息
 * @param s32IconMenuNum 窗口菜单里面的图标的数量
 * @param s32NewBkcolor 图标背景颜色
 * @param u32Id 菜单的消息id 接受和发送消息的时候用到
 * @param u32ParentWnd 主窗口的id，标识了菜单建立在那个主窗口上面
 * @param u32WndHeight 菜单的高度
 * @param u32WndWidth 菜单的宽度
 * @param u32WndX 菜单的x坐标
 * @param u32WndY 菜单的y坐标
 * @param u23IconMenuWidth 图标在菜单里面的宽度
 * @param u32IconMenuHeight 图标在菜单里面的高度
 * @param u64AddData 附加到菜单的数据地址 MINI_INTF_GetAddDate 可以获取到
 * @param u64Style 风格
 * @param WndMsgProc 消息回调函数
 * @see
 */
unsigned int MINI_INTF_CreateMenuByIcon(DWORD u64Style,
										unsigned int u32Id,
										unsigned int u32WndX, unsigned int u32WndY, unsigned int u32WndWidth, unsigned int u32WndHeight,
										HWND u32ParentWnd, DWORD u64AddData,
										MINI_INTF_ICON_MENU_S *pstIconMenu, int s32IconMenuNum,
										unsigned int u23IconMenuWidth, unsigned int u32IconMenuHeight,
										void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{

	HWND u32WndMenu;
	int s32Num;
	if(pstIconMenu == NULL) {
		QLOG(ERR, "传入的图标消息不能为空\n");
		return 0;
	}

	if(s32IconMenuNum <= 0) {
		QLOG(ERR, "传入的图标消息数量必须大于0\n");
		return 0;
	}

    if(u32WndWidth == 0 || u32WndHeight == 0) {
		QLOG(ERR, "图标菜单的长宽必须大于 0 \n");
		return 0;
	}




	u32WndMenu = MINI_INTF_CreateMenuWndByIcon(u64Style,
										u32Id,
										u32WndX, u32WndY, u32WndWidth, u32WndHeight,
										u32ParentWnd, u64AddData,
										WndMsgProc);



	//MINI_INTF_SetWindowBkColor(u32WndMenu, s32NewBkcolor);





	/* 设置图标控件大小 图标大小在一个画板里面是一样大小的*/
	SendMessage (u32WndMenu, IVM_SETITEMSIZE, u23IconMenuWidth, u32IconMenuHeight);

	IVITEMINFO stIconItem;

	for(s32Num = 0; s32Num < s32IconMenuNum; s32Num++) {
		MINI_INTF_AddIconToMenuByPath(u32WndMenu, s32Num, &pstIconMenu[s32Num].stIconMenu,
						pstIconMenu[s32Num].s8Name,
						pstIconMenu[s32Num].s8MapPath, &stIconItem, u64AddData);


	}


	return u32WndMenu;

}







/*!
* 销毁由 MINI_INTF_CreateMenuByIcon 创建的图标菜单
* @return	0 成功
* @param u32Wnd MINI_INTF_CreateMenuByIcon 返回的窗口ID
* @param pstIconMenu	 传入 MINI_INTF_CreateMenuByIcon 的图片消息
* @param s32IconMenuNum 传入 MINI_INTF_CreateMenuByIcon 的图片消息的数量
*/
int MINI_INTF_DestroyMenuByIcon(HWND u32Wnd, MINI_INTF_ICON_MENU_S *pstIconMenu, int s32IconMenuNum)
{
	int s32Num;

	/* 销毁下载的图标*/
	for (s32Num = 0; s32Num < s32IconMenuNum; s32Num++) {
		//UnloadBitmap(&pstIconMenu[s32Num].stIconMenu);
		MINI_INTF_DelOneIconMenu(&pstIconMenu[s32Num].stIconMenu);
	}

	DestroyWindow(u32Wnd);

	return 0;
}


#endif
















/*!
 * 创建一个列表菜单窗口 之后可以通过 MINI_INTF_ScrollCtrlAdd 添加控件
 * @return  创建的窗口的id
 * @param MenuListCallBack 回调函数
 * @param s32Id  消息id
 * @param s32WinX 窗口x坐标
 * @param s32WndHeight 窗口高度
 * @param s32WndWidth 窗口宽度
 * @param s32WndY 窗口y坐标
 * @param u32ParentWnd 父窗口id 指出要在哪个主窗口上面创建
 * @param u32Style 窗口风格
 * @param u64AddDate 附加数据 MINI_INTF_GetAddDate 可以获取到
 * @see
 */
unsigned int MINI_INTF_CreateScrollCtrlWnd(DWORD u32Style, int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd,
									int (*MenuListCallBack)(HWND u32Wnd, int s32Message, WPARAM u32Param, LPARAM u64Param),
									DWORD u64AddDate)
{
	unsigned int WndMenuList;

	WndMenuList = CreateWindow(CTRL_SCROLLWND,
										"",
										u32Style,
										s32Id,
										s32WinX,
										s32WndY,
										s32WndWidth,
										s32WndHeight,
										u32ParentWnd, 0);

	SetWindowAdditionalData (WndMenuList, u64AddDate);

	if(MenuListCallBack) {

		/* 设置回调函数*/
		//SendMessage (WndMenuList, SVM_SETCONTAINERPROC, 0, (LPARAM)MenuListCallBack);
	}

	return WndMenuList;
}


/*!
 * 设置列表窗口的总大小，屏幕未显示的通过拖动滚轮可以看到
 * @param s32WndHight 列表窗口的总高度
 * @param s32WndWidth 列表窗口的总宽度
 * @param WndMenuList 要设置的列表窗
 * @see
 */
void MINI_INTF_ScrollCtrlSetCententSize(unsigned int WndMenuList, int s32WndWidth, int s32WndHight)
{

	SendMessage(WndMenuList, SVM_SETCONTRANGE, s32WndWidth, (LPARAM)s32WndHight);
}

/*!
 * 添加一个控件到列表控件窗口
 * @param pstMenuList 窗口id 指出要往哪个窗口添加列表控件
 * @param s32MenuListNum 要添加的控件的个数
 * @param WndMenuList 要添加的控件的指针
 * @see
 */
void MINI_INTF_ScrollCtrlAdd(unsigned int WndMenuList, CTRLDATA *pstMenuList, int s32MenuListNum)
{

	SendMessage(WndMenuList, SVM_ADDCTRLS, (WPARAM)s32MenuListNum, (LPARAM)pstMenuList);
}

/*!
 * 通过 CTRLDATA 里面的id找到控件的窗口id，然后通过窗口id和窗口通用函数设置控件的属性
 * @return  找到的窗口id
 * @param s32Id 要获取的窗口id的消息id
 * @param WndMenuList 窗口id，指出要获取哪个列表窗口里面的控件窗口id
 * @see
 */
unsigned int MINI_INTF_ScrollCtrlGetWndId(unsigned int WndMenuList, int s32Id)
{

	return SendMessage(WndMenuList, SVM_GETCTRL, s32Id, 0);

}



/*!
 * 创建一个了列表按钮菜单窗口
 * @return	创建窗口的id -1 失败
 * @param u64Style   窗口风格 和普通的窗口一样
 * @param s32Id 创建的菜单消息ID 发送消息时用到
 * @param s32WndX 窗口的X坐标
 * @param s32WndY 窗口的Y坐标
 * @param s32WndWidth 窗口的宽度
 * @param s32WndHeight 窗口的高度
 * @param pstMenuList 创建的列表按钮菜单的消息
 * @param s32MenuListNum pstMenuList的个数
 * @param u32ParentWnd 窗口的父窗口ID 需要在哪个窗口上面建立按钮窗口
 * @param MenuListCallBack 回调函数
 * @param s32NewBkColor 按钮的颜色
 * @param pstFont 按钮字体 销毁窗口的时候需要自己销毁
 */
HWND MINI_INTF_CreateListMenu(DWORD u32Style, int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd,
									CTRLDATA *pstMenuList, int s32MenuListNum,
									int s32ButtonHight,
									DWORD u64AddDate,
									int (*MenuListCallBack)(HWND hWnd, int message, WPARAM wParam, LPARAM lParam),
									int s32NewBkColor,
									PLOGFONT pstFont)
{

	int s32Num;
	HWND WndMenuList;

	if(pstMenuList == NULL) {
		QLOG(ERR, "列表菜单参数为空\n");
		return -1;
	}
	if(MenuListCallBack == NULL) {
		QLOG(ERR, "回调函数为空\n");
		return -1;
	}

	WndMenuList = MINI_INTF_CreateScrollCtrlWnd(u32Style, s32Id,
									s32WinX, s32WndY, s32WndWidth, s32WndHeight,
									u32ParentWnd,
									MenuListCallBack,u64AddDate);



	for(s32Num = 0; s32Num < s32MenuListNum; s32Num++) {
		/* 计算列表里面按钮的位置*/
		pstMenuList[s32Num].x = 0;
		pstMenuList[s32Num].y = s32Num*s32ButtonHight;
		pstMenuList[s32Num].w = s32WndWidth;
		pstMenuList[s32Num].h = s32ButtonHight;
	}

	/* 设置字体*/
	if(pstFont) {
		SetWindowFont(WndMenuList, pstFont);
	}

	MINI_INTF_ScrollCtrlSetCententSize(WndMenuList, s32WndWidth, s32ButtonHight* s32MenuListNum);



	MINI_INTF_ScrollCtrlAdd(WndMenuList, pstMenuList, s32MenuListNum);

#if 0
	/* 设置按钮风格*/
	for(s32Num = 0; s32Num < s32MenuListNum; s32Num++) {
		/* 获取每个按钮的窗口ID*/

		u32ButtonWnd = MINI_INTF_ScrollCtrlGetWndId(WndMenuList, s32Id);

		MINI_INTF_SetWindowFont(u32ButtonWnd, pstFont);
		//MINI_INTF_SetWindowBkColor(u32ButtonWnd, COLOR_yellow);
		MINI_INTF_SetWindowBkColor(u32ButtonWnd, s32NewBkColor);
	}
#endif
	return WndMenuList;
}

















/*!
 * 创建一个静态显示框窗口 通过 MINI_INTF_SetWindowText 可以改变显示的内容，可以做 OSD 也可以显示图片
 * @return  返回创建的窗口id
 * @param ps8DisplayText 初始创建的内容
 * @param s32Id 消息id
 * @param s32WinX 窗口坐标x
 * @param s32WndHeight 窗口高度
 * @param s32WndWidth 窗口宽度
 * @param s32WndY 窗口y坐标
 * @param u32ParentWnd 父窗口id，指出要在哪个窗口上面创建
 * @param u32Style 窗口风格 显示图片 WS_CHILD | SS_BITMAP | WS_VISIBLE | SS_REALSIZEIMAGE | SS_CENTERIMAGE
 * @param u64AddDate 窗口附加数据 MINI_INTF_GetAddDate 可以获取到
 * @see
 */
unsigned int MINI_INTF_CreateStaticDisplay(char *ps8DisplayText, DWORD u32Style, int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate)
{

	unsigned int u32WndId;

	u32WndId = CreateWindow (CTRL_STATIC, ps8DisplayText,
					   u32Style,
					   s32Id,
					   s32WinX,
					   s32WndY,
					   s32WndWidth,
					   s32WndHeight,
					   u32ParentWnd, u64AddDate);

	return u32WndId;
}







/*!
 * 创建月历控件 创建后需要用 MINI_INTF_CreateLogFontGb2312(int s32Size) 修改字体，因为系统月历使用的是 GB2312 字体
 * @return  返回创建的月历窗口id
 * @param s32Id 窗口消息id
 * @param s32WinX 窗口x坐标
 * @param s32WndHeight 窗口高度
 * @param s32WndWidth 窗口宽度
 * @param s32WndY 窗口y坐标
 * @param u32ParentWnd 父窗口，指出要在哪个主窗口创建月历控件
 * @param u32Style 窗口风格
 * @param u64AddDate 窗口附加数据 MINI_INTF_GetAddDate 可以获取到
 * @see
 */
unsigned int MINI_INTF_CreateMouthCalendarWindow(DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;
	u32WndId = CreateWindow("monthcalendar_pri",
							"",
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);
	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}
	return u32WndId;
}



/*!
 * 获取月历控件的颜色
 * @param pstColor 颜色的结构体，存放获取到的颜色
 * @param s32WndId 要获取颜色的结构体
 * @see
 */
void MINI_INTF_GetMonthColor(unsigned int s32WndId, MCCOLORINFO *pstColor)
{

	SendMessage(s32WndId, MCM_GETCOLOR, 0, (LPARAM)pstColor);
}

/*!
 * 设置月历控件的颜色
 * @param pstColor 颜色结构体，根据此结构体设置颜色
 * @param s32WndId 要设置的窗口
 * @see
 */
void MINI_INTF_SetMonthColor(unsigned int s32WndId, MCCOLORINFO *pstColor)
{
	SendMessage(s32WndId, MCM_SETCOLOR, 0, (LPARAM)pstColor);
}


/*!
 * 单独设置月历控件的某一天的颜色
 * @param pstSpecialColor 颜色的结构体，填充要设置哪一天的结构体
 * @param s32Color 要设置的颜色
 * @param s32WndId 要设置的窗口
 * @see
 */
void MINI_INTF_SetMonthOneDayTextColor(unsigned int s32WndId, DAY_COLOR_PRI_S *pstSpecialColor, int s32Color)
{
	SendMessage(s32WndId, MCM_SETDAYCOLOR, (WPARAM)pstSpecialColor, s32Color);
}


/*!
 * 获取当前选择的月历的时间
 * @param pstSystime 存放当前获取到的时间
 * @param s32WndId 指定获取哪个窗口的当前选择时间
 * @see
 */
void MINI_INTF_GetMonthDayOfOption(unsigned int s32WndId, SYSTEMTIME *pstSystime)
{
	SendMessage (s32WndId, MCM_GETCURDATE, 0, (LPARAM)pstSystime);
}












/*!
 * 创建一个按钮
 * @return  返回创建的按钮的窗口id
 * @param pstStr 按钮显示的字符串
 * @param s32Id 按钮消息id
 * @param s32WinX 按钮窗口的x坐标
 * @param s32WndHeight 按钮窗口的高
 * @param s32WndWidth 按钮窗口的宽
 * @param s32WndY 按钮窗口的y坐标
 * @param u32ParentWnd 父窗口id 指定在哪个窗口上面创建按钮
 * @param u32Style 按钮风格 普通按钮 			BS_DEFPUSHBUTTON
 * 							复选框按钮		BS_CHECKBOX  应用程序需要自己向该控件发送消息来设定选中标记
 *										BS_AUTOCHECKBOX 风格时，控件会自动在选中和非选中状态之间切换
 *							单选按钮 有风格 BS_RADIOBUTTON 或 BS_AUTORADIOBUTTON 两种，后者会自动显示用户的选择情况，而前者不会
 * @param u64AddDate 按钮窗口附加数据
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateButtonWnd(char *pstStr, DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									NOTIFPROC WndMsgProc)
{

	unsigned int u32WndId;
	u32WndId = CreateWindow(CTRL_BUTTON,
							pstStr,
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);
	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
		//SetWindowCallbackProc(u32WndId, WndMsgProc);
	}


	return u32WndId;

}

/*!
 * 获取普通按钮或者复选框的状态
 * @return	BST_CHECKED 按下状态 0.正常
 * @param u32WndId
 * @see
 */
int MINI_INTF_GetButtonStatus(unsigned int u32WndId)
{
	return SendMessage(u32WndId, BM_GETSTATE, 0, 0);
}

/*!
 * 设置普通按钮或者复选框的按下或释放状态
 * @param s32Sta 要设置的状态 BST_CHECKED 按下状态 0.恢复正常
 * @param u32WndId
 * @see
 */
void MINI_INTF_SetButtonStatus(unsigned int u32WndId, int s32Sta)
{
	SendMessage(u32WndId, BM_SETSTATE, s32Sta, 0) ;
}


/*!
 * 获取复选框或单选按钮状态
 * @return  复选框状态 BST_UNCHECKED(0) 未选中  BST_CHECKED(1) 已选中  BST_INDETERMINATE(2) 不可用状态
 * @param u32WndId
 * @see
 */
int MINI_INTF_GetiButtonCheck(unsigned int u32WndId)
{
	return SendMessage(u32WndId, BM_GETCHECK, 0, 0);
}

/*!
 * 设置复选按钮或单选按钮状态
 * @param u32WndId
 * @param s32Sta 要设置的状态 BST_UNCHECKED(0) 未选中  BST_CHECKED(1) 已选中  BST_INDETERMINATE(2) 不可用状态
 * @see
 */
void MINI_INTF_SetButtonCheck(unsigned int u32WndId, int s32Sta)
{
	SendMessage(u32WndId, BM_SETCHECK, s32Sta, 0) ;
}















unsigned int MINI_INTF_CreateStaticPictureWnd(char *pstStr, DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData),
									BITMAP *pstBitMap,
									char *ps8PicturePath)
{
	unsigned int u32WndId;
	HDC hdc = GetDC(u32ParentWnd);
	LoadBitmap(hdc, pstBitMap, ps8PicturePath);

	DWORD u64RealStyle = u32Style|SS_BITMAP|SS_NOTIFY;

	u32WndId = MINI_INTF_CreateWnd(CTRL_STATIC, pstStr,
									u64RealStyle,
									s32Id,
									s32WinX, s32WndY, s32WndWidth, s32WndHeight,
									u32ParentWnd,
									(DWORD)pstBitMap,
									WndMsgProc);
	SetWindowAdditionalData(u32WndId, u64AddDate);
	ReleaseDC(hdc);

	return u32WndId;

}


unsigned int MINI_INTF_CreateStaticTextWnd(char *pstStr, DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;

	u32WndId = MINI_INTF_CreateWnd(CTRL_STATIC, pstStr,
									u32Style,
									s32Id,
									s32WinX, s32WndY, s32WndWidth, s32WndHeight,
									u32ParentWnd,
									u64AddDate,
									WndMsgProc);

	return u32WndId;

}








/*!
 * 创建一个进度条
 *  进度条通知码
 * 条具有 PBS_NOTIFY 风格，则可能产生如下通知消息：
 * 				ACHMAX：已到达最大进度位置。
 * 				ACHMIN：已到达最小进度位置。
 * @return	返回创建的进度条的窗口id
 * @param pstStr 进度条显示的字符串
 * @param s32Id 进度条消息id
 * @param s32WinX 进度条窗口的x坐标
 * @param s32WndHeight 进度条窗口的高
 * @param s32WndWidth 进度条窗口的宽
 * @param s32WndY 进度条窗口的y坐标
 * @param u32ParentWnd 父窗口id 指定在哪个窗口上面创建进度条
 * @param u32Style 进度条风格 		PBS_NOTIFY：使用该风格的进度条控件会产生通知消息。
 *								PBS_VERTICAL：竖直显示进度条
 *				常用组合 WS_CHILD | WS_VISIBLE | PBS_NOTIFY
 * @param u64AddDate 进度条窗口附加数据
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateWndProgreBar(char *pstStr, DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;
	u32WndId = CreateWindow(CTRL_PROGRESSBAR,
							pstStr,
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);
	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}
	return u32WndId;

}


/*!
 * 设置进度条的范围值 默认0到100 进度条的范围可以设置为负值。
 * @param s32Max 最大值
 * @param s32Min 最小值
 * @param u32WndId 要设置的窗口
 * @see
 */
void MINI_INTF_SetProgreBarRange(unsigned int u32WndId, int s32Min, int s32Max)
{
	SendMessage(u32WndId, PBM_SETRANGE, s32Min, (LPARAM)s32Max);
}




/*!
 * 设置步进长度 我们可以为进度条设置步进长度，然后在每完成一个阶段性任务时，使进度条步进。默认的进度条步进值是 10
 * 进度条的步进值可以设置为负值。
 * 当进度条的步进值为负值时，需要设置进度条的位置为进度条范围的最大值。这样进度
 * 示时进度条从范围的最大值减小到进度条范围的最小值。
 * @param s32Step 要设置的步进长度
 * @param u32WndId 要设置的窗口
 * @see
 */
void MINI_INTF_SetProgreBarStep(unsigned int u32WndId, int s32Step)
{
	SendMessage (u32WndId, PBM_SETSTEP, (WPARAM)s32Step, 0) ;
}

/*!
 * 使进度条前进一个步进值 进度条增加 MINI_INTF_SetProgreBarStep 设置的进度
 * @param u32WndId 要设置的窗口
 * @see
 */
void MINI_INTF_SetProgreBarPit(unsigned int u32WndId)
{
	SendMessage (u32WndId, PBM_STEPIT, 0, 0) ;
}






/*!
 * 设置进度条位置
 * @param s32Pos 要设置的位置
 * @param u32WndId 要设置的窗口
 * @see
 */
void MINI_INTF_SetProgreBarpPos(int u32WndId, int s32Pos)
{
	SendMessage (u32WndId, PBM_SETPOS, (WPARAM)s32Pos, 0) ;
}



/*!
 * 在当前进度基础上偏移
 * @param s32Pos 要偏移的值
 * @param u32WndId 要便宜的窗口
 * @see
 */
void MINI_INTF_SetProgreBarpAddPos(int u32WndId, int s32Pos)
{
	SendMessage (u32WndId, PBM_DELTAPOS, (WPARAM)s32Pos, 0);
}

















/*!
 * 创建文本编辑框  MINI_INTF_GetWindowTextLength MINI_INTF_GetWindowText 可以获取编辑框的文本长度和内容
 * 编辑框没有 ES_NOTIFY 风格，因此，任意一个编辑框控件均可能产生通知消息，通知码如下所列：
 * 	• EN_SETFOCUS：编辑控件已经获得输入焦点
 *	• EN_KILLFOCUS：编辑控件已经失去输入焦点
 *	• EN_CHANGE：编辑控件的内容已经改变
 *	• EN_UPDATE: 编辑控件在接收到 MSG_SETTEXT， EM_RESETCONTENT 或 EM_SETLINEHEIGHT 消息后，内容已经改变
 *	• EN_ENTER：用户在编辑框中按下了 Enter 键
 *	• EN_MAXTEXT：编辑控件在插入时超出了限定长度
 *	• EN_DBLCLK： 编辑控件被鼠标左键双击
 *	• EN_CLICKED：编辑控件被鼠标左键点击
 * @return	返回创建的编辑框的窗口id
 * @param s32Type 编辑框的类型 0.单行编辑框 1.多行编辑框 2.单行双向文本编辑框
 * @param s32Id 编辑框消息id
 * @param s32WinX 编辑框窗口的x坐标
 * @param s32WndHeight 编辑框窗口的高
 * @param s32WndWidth 编辑框窗口的宽
 * @param s32WndY 编辑框窗口的y坐标
 * @param u32ParentWnd 父窗口id 指定在哪个窗口上面创建编辑框
 * @param u32Style 编辑框风格 通用风格 WS_CHILD | WS_VISIBLE | WS_BORDER
 *
 * @param u64AddDate 编辑框窗口附加数据
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateWndEdit(int s32Type,
									DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;
	char *ps8Type = NULL;

	switch(s32Type) {
		case 0:
			ps8Type = CTRL_SLEDIT;
			break;
		case 1:
			ps8Type = CTRL_TEXTEDIT;
			break;
		case 2:
			ps8Type = CTRL_BIDISLEDIT;
			break;
		default:
			QLOG(ERR, "编辑框类型错误\n");
			return 0;
	}


	u32WndId = CreateWindow(ps8Type,
							"",
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);

	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}
	return u32WndId;

}


/*!
 * 往编辑框里面添加一行字符串，不会删除之前的字符串，其他地方应该也可以用
 * @param ps8Buf 要添加的字符串
 * @param u32WndId 编辑框的窗口id
 * @see
 */
void MINI_INTF_EditAddTextOneLine(unsigned int u32WndId, char* ps8Buf)
{
	SendMessage(u32WndId, EM_INSERTTEXT, (WPARAM)strlen(ps8Buf), (LPARAM)ps8Buf);
}

/*!
 * 将指定的文本插入到当前插入符号位置 ，不会删除之前的字符串 ，建议用上面的那个
 * @param ps8Buf 要插入的字符串
 * @param s32Len 字符串的长度 注意字符串结尾的 '\0'不能计算到长度里面，否则显示效果不能达到预期
 *					如果传多行 可以传 -1
 * @param u32WndId 窗口id
 * @see
 */
void MINI_INTF_EditAddText(unsigned int u32WndId, char* ps8Buf, int s32Len)
{
	SendMessage(u32WndId, EM_INSERTTEXT, (WPARAM)s32Len, (LPARAM)ps8Buf);
}

/*!
 * 限制编辑框的文本上限，以字节为单位
 * @param s32Limit 要限制的大小，以字节为单位 '\0'不计算在内
 * @param u32WndId 要限制的编辑框的窗口id
 * @see
 */
void MINI_INTF_EditSetLimit(unsigned int u32WndId, int s32Limit)
{
	SendMessage (u32WndId, EM_LIMITTEXT, (WPARAM)s32Limit, 0L);
}




/*!
 * 设置编辑框只读属性
 * @param bSwitch false 取消只读 true 只读
 * @param u32WndId 要设置的编辑框
 * @see
 */
void MINI_INTF_EditSetReadOnly(unsigned int u32WndId, bool bSwitch)
{
	BOOL u8ReadOnly;
	if(bSwitch == 1) {
		u8ReadOnly = TRUE;
	} else if(bSwitch == false) {
		u8ReadOnly = FALSE;
	}

	SendMessage (u32WndId, EM_SETREADONLY, (WPARAM)u8ReadOnly, 0L);
}


/*!
 * 设置编辑框的提示, 当编辑框为单行编辑框，且风格有 ES_TIP 的时候，在没有输入的情况下显示
 * @param ps8Buf 提示字符串
 * @param s32Len 字符串长度 如果要传多行字符串 长度就填 -1
 * @param u32WndId 要设置的编辑框窗口id
 * @see
 */
void MINI_INTF_EditSetTipText(unsigned int u32WndId, char* ps8Buf, int s32Len)
{

	SendMessage (u32WndId, EM_SETTIPTEXT, (WPARAM)s32Len, (LPARAM)ps8Buf);
}


/*!
 * 获取当前提示文字的字符串
 * @param ps8Buf 获取字符串存储的buf
 * @param s32Len 字符串的长度
 * @param u32WndId 要获取的编辑框
 * @see
 */
void MINI_INTF_EditGetTipText(unsigned int u32WndId, char* ps8Buf, int s32Len)
{

	SendMessage (u32WndId, EM_GETTIPTEXT, (WPARAM)s32Len, (LPARAM)ps8Buf);
}




/*!
 * 设置编辑框的标题 当为多行编辑框，且具有 ES_TITLE 风格时有效，标题不能在客户区被删除
 * @param ps8Buf 要设置的字符串
 * @param s32Len 字符串的长度
 * @param u32WndId 要设置的编辑框
 * @see
 */
void MINI_INTF_EditSetTitleText(unsigned int u32WndId, char* ps8Buf, int s32Len)
{
	SendMessage (u32WndId, EM_SETTITLETEXT, (WPARAM)s32Len, (LPARAM)ps8Buf);
}

/*!
 * 获取编辑框的标题
 * @param ps8Buf 存放获取到的标题
 * @param s32Len 存放字符串的疮毒
 * @param u32WndId 要获取的编辑框
 * @see
 */
void MINI_INTF_EditGetTitleText(unsigned int u32WndId, char* ps8Buf, int s32Len)
{
	SendMessage (u32WndId, EM_GETTITLETEXT, (WPARAM)s32Len, (LPARAM)ps8Buf);
}


































/*!
 * 创建一个旋钮按钮
 * @return  创建的旋钮按钮窗口id
 * @param s32Id 消息id
 * @param s32WinX 窗口x坐标
 * @param s32WndHeight 窗口高度
 * @param s32WndWidth 窗口宽度
 * @param s32WndY 窗口y坐标
 * @param u32ParentWnd 父窗口id，指出要在哪个窗口创建旋钮按钮
 * @param u32Style 窗口风格 旋钮控件目前具有的唯一风格是 SPS_AUTOSCROLL。该风格的旋钮控件可以自动判断旋钮控件目前的滚动状态，在滚动到最
 *	大值和最小值时分别把向上和向下箭头禁止掉（变灰）。没有该风格的旋钮控件的滚动状态由应用程序掌握。
 * @param u64AddDate 附加数据
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateWndSpin(DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;


	u32WndId = CreateWindow(CTRL_SPINBOX,
							"",
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);

	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}
	return u32WndId;

}

/*!
 * 设置旋钮的基本消息
 * @param s32Cur 旋钮当前只
 * @param s32Max 旋钮最大值
 * @param s32Min 旋钮最小值
 * @param u32WndId 旋钮的窗口
 * @see
 */
void MINI_INTF_SipnSetInfo(unsigned int u32WndId,  int s32Max, int s32Min, int s32Cur)
{
	SPININFO stSpInfo;
	stSpInfo.max = s32Max;
	stSpInfo.min = s32Min;
	stSpInfo.cur = s32Cur;
	SendMessage(u32WndId, SPM_SETINFO, 0, (LPARAM)&stSpInfo);
}


/*!
 * 获取旋钮的属性
 * @param pstSpInfo 存放旋钮数据的结构体指针
 * @param u32WndId 要获取的旋钮窗口id
 * @see
 */
void MINI_INTF_SipnGetInfo(unsigned int u32WndId,  SPININFO *pstSpInfo)
{
	SendMessage(u32WndId, SPM_GETINFO, 0, (LPARAM)pstSpInfo);
}


/*!
 * 设置旋钮当前值
 * @param s32Cur 旋钮当前值
 * @param u32WndId 旋钮窗口id
 * @see
 */
void MINI_INTF_SipnGetCur(unsigned int u32WndId, int s32Cur)
{
	SendMessage(u32WndId, SPM_SETCUR, (WPARAM)s32Cur, 0);
}


/*!
 * 使能旋钮
 * @param u32EnbleSwitch 1.上键使能 2.上键失效 3.下键使能 4.下键失效
 * @param u32WndId
 * @see
 */
int MINI_INTF_SipnEnble(unsigned int u32WndId, unsigned int u32EnbleSwitch)
{
	unsigned int u32Enble;
	switch(u32EnbleSwitch) {
		case 1:
			u32Enble = SPM_ENABLEUP;
		break;
		case 2:
			u32Enble = SPM_DISABLEUP;
		break;
		case 3:
			u32Enble = SPM_ENABLEDOWN;
		break;
		case 4:
			u32Enble = SPM_DISABLEDOWN;
		break;
		default:
			QLOG(ERR, "旋钮使能参数错误\n");
			return -1;
	}

	return SendMessage (u32WndId, (WPARAM)u32Enble, 0, 0);
}


/*!
 * 设置旋钮控件的目标窗口 用户点击旋钮控件的上下箭头时，旋钮控件将向它的目标窗口发送 MSG_KEYDOWN 和 MSG_KEYUP 消息， wParam 参数为
 * 	SCANCODE_CURSORBLOCKUP（点击上箭头时）或 SCANCODE_CURSORBLOCKDOWN（点击下箭头时）， lParam 参数将设置
 *	KS_SPINPOST 标志位，指明该消息来自旋钮控件
 * @param u23SpinWndId 旋钮窗口id
 * @param u23TargetWndId 要绑定的控件窗口id
 * @see
 */
void MINI_INTF_SipnSetTarget(unsigned int u32WndId, unsigned int u32TargetWndId)
{
	SendMessage(u32WndId, SPM_SETTARGET, 0, (LPARAM)u32TargetWndId) ;
}

/*!
 * 获取旋钮绑定的窗口
 * @return 绑定的窗口的
 * @param u23SpinWndId 旋钮的窗口id
 * @see
 */
unsigned int MINI_INTF_SipnGetTarget(unsigned int u32WndId)
{
	return SendMessage (u32WndId, SPM_GETTARGET, 0, 0) ;
}

























/*!
 * 创建一个组合框
 * 当组合框具有 CBS_NOTIFY 风格时，将可能产生通知消息。组合框通知消息的通知码基本上是列表框通知码和编辑框通知码
 *		的组合，如下所列：
 *		• CBN_ERRSPACE：内存不足
 *		• CBN_SELCHANGE：条目选择变化
 *		• CBN_EDITCHANGE：方框区域的文本发生了变化
 *		• CBN_DBLCLK：用户双击了组合框中的某个条目
 *		• CBN_CLICKED：用户点击了组合框
 *		• CBN_SETFOCUS：组合框获得了输入焦点。如果组合框具有 CBS_AUTOFOCUS 风格，则内部编辑框将同时获得输入焦
 *		点。
 *		• CBN_KILLFOCUS：组合框失去了输入焦点。
 *		• CBN_DROPDOWN：用户下拉列表框使之显示。当用户点击编辑框旁边的向下箭头按钮或者在编辑框中键入光标控制
 *		键，比如向下、向上箭头键， PageDown 或者 PageUp? 等键时，也会下拉并显示列表框。
 *		• CBN_CLOSEUP：下拉的列表框被隐藏（关闭）。
 *		• CBN_SELENDOK：用户从下拉列表框中选择了某个条目。
 *		• CBN_SELENDCANCEL：用户未选择任何条目而关闭下拉列表框。
 * @return  返回创建的组合框窗口
 * @param s32Id 窗口的消息id
 * @param s32WinX 窗口的x坐标
 * @param s32WndHeight 窗口的高度
 * @param s32WndWidth 窗口的宽度
 * @param s32WndY 窗口的y坐标
 * @param u32ParentWnd 窗口的父窗口
 * @param u32Style 窗口的风格
 * @param u32TypeSwitch 创建那种组合窗口 1.普通 2.下拉 3.旋钮 4.旋钮数字
 * @param u64AddDate 附加数据 创建下拉组合框的时候传递下拉列表的高度
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateWndDropDownList(unsigned int u32TypeSwitch, DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;
	unsigned long int u32Type;

	switch(u32TypeSwitch) {
		case 1:
			/* 普通组合框*/
			u32Type = CBS_SIMPLE;
			break;
		case 2:
			/* 下拉组合框*/
			u32Type = CBS_DROPDOWNLIST;
			break;
		case 3:
			/* 旋钮组合框*/
			u32Type = CBS_SPINLIST ;
			break;
		case 4:
			/* 旋钮数字框*/
			u32Type = CBS_AUTOSPIN ;
			break;
	}


	u32WndId = CreateWindow(CTRL_COMBOBOX,
							"",
							u32Style | u32Type,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);


	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}

	return u32WndId;

}




/*!
 * 添加一个条目
 * @param ps8String 要添加的条目
 * @param u23SpinWndId 要添加的窗口
 * @see
 */
void MINI_INTF_DropDownAddStr(unsigned int u32WndId, char *ps8String)
{
	SendMessage (u32WndId, CB_ADDSTRING, 0, (LPARAM)ps8String);
}

/*!
 * 通过条索引入一个条目 例如，如果 index 等于 4，那么 string 将变为索引值为 4 的字符串――从顶头开始算起的第 5 个字符串（因为是从 0 开始
 * 计数的），位于这个点后面的所有字符串都将向后推移。索引值为 -1 时，将字符串增加在最后
 * @param ps8String 要添加的条目
 * @param s32Index 添加的索引
 * @param u23SpinWndId 要添加的窗口
 * @see
 */
void MINI_INTF_DropDownAddStrByIndex(unsigned int u32WndId, int s32Index, char *ps8String)
{
	SendMessage (u32WndId, CB_INSERTSTRING, (WPARAM)s32Index, (LPARAM)ps8String);
}



/*!
 * 通过索引删除一个条目
 * @param s32Index 要删除条目的索引
 * @param u23SpinWndId 组合框的窗口id
 * @see
 */
void MINI_INTF_DropDownDelStrByIndex(unsigned int u32WndId, int s32Index)
{
	SendMessage (u32WndId, CB_DELETESTRING, (WPARAM)s32Index, 0);
}


/*!
 * 通过条目找到索引
 * @return  返回找到的索引 LB_ERR 查找失败
 * @param ps8String 要寻找的条目
 * @param u23SpinWndId 窗口id
 * @see
 */
int MINI_INTF_DropDownFindStr(unsigned int u32WndId, char *ps8String)
{
	return SendMessage (u32WndId, CB_FINDSTRING, 0, (LPARAM)ps8String);
}


/*!
 * 获取条目总数量
 * @return  返回条目总素
 * @param u32WndId 要获取的组合框
 * @see
 */
int MINI_INTF_DropDownGetCount(unsigned int u32WndId)
{
	return SendMessage (u32WndId, CB_GETCOUNT, 0, 0);
}

/*!
 * 用于获取内部列表框的当前选中项。
 * @return 返回当前条目选项的索引 如果没有选中条目则返回 LB_ERR
 * @param u32WndId 要获取组合框的窗口id
 * @see
 */
int MINI_INTF_DropDownGetCursel(unsigned int u32WndId)
{
	return SendMessage (u32WndId, CB_GETCURSEL, 0, 0);
}

/*!
 * 用于设置内部列表框的当前选中项。
 * @return 返回当前条目选项的索引 如果没有选中条目则返回 LB_ERR
 * @param s32Index 要显示的条目的索引
 * @param u32WndId 要获取组合框的窗口id
 * @see
 */
int MINI_INTF_DropDownSetCursel(unsigned int u32WndId, int s32Index)
{
	return SendMessage(u32WndId, CB_SETCURSEL, (WPARAM)s32Index, 0);
}


/*!
 * 用于清空内部列表框
 * @param u32WndId 要清空的组合框id
 * @see
 */
void MINI_INTF_DropDownResetContent(unsigned int u32WndId)
{
	SendMessage(u32WndId, CB_RESETCONTENT, 0, 0);
}


/*!
 * 用于设置内部列表框条目的附加数据
 * @param pAddDate 要设置的附加数据的地址
 * @param u32WndId 组合框id
 * @see
 */
void MINI_INTF_DropDownSetAddDate(unsigned int u32WndId, void* pAddDate)
{
	SendMessage(u32WndId, CB_SETITEMADDDATA, 0, (LPARAM)pAddDate);
}


/*!
 * 用于获取内部列表框条目的附加数据
 * @param pAddDate 获取的附加数据的地址
 * @param u32WndId 组合框id
 * @see
 */
void MINI_INTF_DropDownGetAddDate(unsigned int u32WndId, void* pAddDate)
{
	SendMessage(u32WndId, CB_GETITEMADDDATA, 0, (LPARAM)pAddDate);
}


/*!
 * 用于获取内部列表框条目的高度
 * @return 返回获取到的高度
 * @param u32WndId 组合框窗口id
 * @see
 */
int MINI_INTF_DropDownGetHeight(unsigned int u32WndId)
{
	return SendMessage(u32WndId, CB_GETITEMHEIGHT, 0, 0);
}


/*!
 * 用于设置内部列表框条目的高度
 * @param s32Height 要设置的高度 （测试的时候发现设的值太小会无效）
 * @param u32WndId 组合框窗口id
 * @see
 */
void MINI_INTF_DropDownSetHeight(unsigned int u32WndId, int s32Height)
{
	SendMessage(u32WndId, CB_SETITEMHEIGHT, 0, (LPARAM)s32Height);
}





/*!
 * 用于获取内部列表框条目的文本内容
 * @return 内容的长度
 * @param ps8Buf 获取到的内容的缓存buf
 * @param s23Index 要获取的条目的索引
 * @param u32WndId 组合框的窗口id
 * @see
 */
int MINI_INTF_DropDownGetText(unsigned int u32WndId, int s32Index, char *ps8Buf)
{
	return SendMessage (u32WndId, CB_GETLBTEXT, (WPARAM)s32Index, (LPARAM)ps8Buf) ;
}


/*!
 * 用于获得内部列表框条目的文本长度
 * @return  内部列表框条目的文本长度
 * @param s23Index 要获取的条目的索引
 * @param u32WndId 组合框的窗口id
 * @see
 */
int MINI_INTF_DropDownGetTextLen(unsigned int u32WndId, int s32Index)
{
	return SendMessage (u32WndId, CB_GETLBTEXTLEN, (WPARAM)s32Index, 0) ;
}


/*!
 * 设置编辑框控件的文本上限，以字节为单位
 * @param s32Limit 要设置的上限
 * @param u32WndId 要设置的组合框窗口第
 * @see
 */
void MINI_INTF_DropDownLimitTextLen(unsigned int u32WndId, int s32Limit)
{
	SendMessage (u32WndId, CB_LIMITTEXT, (WPARAM)s32Limit, 0) ;
}


/*!
 * 发送该消息将使旋钮框向前或向后步进，相当于用户单击编辑框旁边的向上或向下箭头（在编辑框中键入
 * 向上或向下箭头键，也可取得一样的效果）  注意只对旋钮框起效果
 * @param bChange 控制步进方向，取 0 为向下，取 1 为向上
 * @param u32WndId 要控制的组合框窗口id
 * @see
 */
void MINI_INTF_DropDownSpin(unsigned int u32WndId, bool bChange)
{
	SendMessage (u32WndId, CB_SPIN, (WPARAM)bChange, 0) ;
}








/*!
 * 获得数字旋钮框可取的最大值和最小值
 * @param pu32Max 获得的最大值
 * @param pu32Min 获得的最小值
 * @param u32WndId 数字旋钮框窗口id
 * @see
 */
void MINI_INTF_DDL_SpinGetRange(unsigned int u32WndId, int *ps32Max, int *ps32Min)
{
	SendMessage (u32WndId, CB_GETSPINRANGE, (WPARAM)ps32Min, (LPARAM)ps32Max);
}


/*!
 * 设置数字旋钮框可取的最大值和最小值
 * @param u32Max 最大值
 * @param u32Min 最小值
 * @param u32WndId 数字旋钮框窗口id
 * @see
 */
void MINI_INTF_DDL_SpinSetRange(unsigned int u32WndId, int s32Max, int s32Min)
{
	SendMessage (u32WndId, CB_SETSPINRANGE, (WPARAM)s32Min, (LPARAM)s32Max);
}

/*!
 * 设置数字旋钮框编辑框的当前数值
 * @param s32Value 要设置的数值
 * @param u32WndId 数字旋钮框窗口id
 * @see
 */
void MINI_INTF_DDL_SpinSetValue(unsigned int u32WndId, int s32Value)
{
	SendMessage (u32WndId, CB_SETSPINVALUE, (WPARAM)s32Value, 0);
}



/*!
 * 获取数字旋钮框当前的数字
 * @return  返回获取到的数字
 * @param u32WndId 数字旋钮框窗口id
 * @see
 */
int MINI_INTF_DDL_SpinGetValue(unsigned int u32WndId)
{
	return SendMessage (u32WndId, CB_GETSPINVALUE, 0, 0);
}





















/*!
 * 创建一个滑块
 *	 当滑块控件具有 TBS_NOTIFY 风格时，可能产生如下通知消息：
 *	• TBN_CHANGE：滑块的位置发生了变化。
 *	• TBN_REACHMAX：已到达了上限。
 *	• TBN_REACHMIN：已到达了下限。
 * @return  返回创建的滑块窗口
 * @param s32Id 窗口的消息id
 * @param s32WinX 窗口的x坐标
 * @param s32WndHeight 窗口的高度
 * @param s32WndWidth 窗口的宽度
 * @param s32WndY 窗口的y坐标
 * @param u32ParentWnd 窗口的父窗口
 * @param u32Style 窗口的风格 如果想要创建竖直的滑块，可指定 TBS_VERTICAL 风格
 * @param u64AddDate 附加数据
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateWndTrackBar(DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									WNDPROC pfWndMsgProc)
{
	unsigned int u32WndId;

	u32WndId = CreateWindow(CTRL_TRACKBAR,
							"",
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);


	if(pfWndMsgProc) {
		//SetNotificationCallback(u32WndId, WndMsgProc);
		SetWindowCallbackProc(u32WndId, pfWndMsgProc);
	}

	return u32WndId;

}


/*!
 * 设置滑块的最小值和最大值。默认的范围是 0~10。
 * @param s32Max 最大值
 * @param s32Min 最小值
 * @param u32WndId 滑块窗口
 * @see
 */
void MINI_INTF_TrackBarSetRange(unsigned int u32WndId, int s32Max, int s32Min)
{
	SendMessage(u32WndId, TBM_SETRANGE, (WPARAM)s32Min, (LPARAM)s32Max);
}


/*!
 * 获取滑块最小值
 * @param u32WndId 滑块窗口
 * @see
 */
int MINI_INTF_TrackBarGetMin(unsigned int u32WndId)
{
	return SendMessage (u32WndId, TBM_GETMIN, 0, 0);
}


/*!
 * 获取滑块最大值
 * @param u32WndId 滑块窗口
 * @see
 */
int MINI_INTF_TrackBarGetMax(unsigned int u32WndId)
{
	return SendMessage (u32WndId, TBM_GETMAX, 0, 0);
}


/*!
 * 设置滑块最小值
 * @param s32Min 最小值 小于0无效
 * @param u32WndId 滑块窗口id
 * @see
 */
void MINI_INTF_TrackBarSetMin(unsigned int u32WndId, int s32Min)
{
	SendMessage (u32WndId, TBM_SETMIN, (WPARAM)s32Min, 0);
}


/*!
 * 设置滑块最大值
 * @param s32Max 最大值
 * @param u32WndId 滑块窗口id
 * @see
 */
void MINI_INTF_TrackBarSetMax(unsigned int u32WndId, int s32Max)
{
	SendMessage (u32WndId, TBM_SETMAX, (WPARAM)s32Max, 0);
}

/*!
 * 设置滑块的步进值
 * @param s32Size  滑块的步进值
 * @param u32WndId 滑块的窗口id
 * @see
 */
void MINI_INTF_TrackBarSetLineSize(unsigned int u32WndId, int s32Size)
{
	SendMessage (u32WndId, TBM_SETLINESIZE, (WPARAM)s32Size, 0);
}

/*!
 * 获得滑块的步进值
 * @return  滑块的步进值
 * @param u32WndId 滑块的窗口id
 * @see
 */
int MINI_INTF_TrackBarGetPageSize(unsigned int u32WndId)
{
	return SendMessage (u32WndId, TBM_GETPAGESIZE, 0, 0);
}

/*!
 * 设置滑块的快速步进值
 * @param s32Size  滑块的快速步进值
 * @param u32WndId 滑块的窗口id
 * @see
 */
void MINI_INTF_TrackBarSetPageSize(unsigned int u32WndId, int s32Size)
{
	SendMessage (u32WndId, TBM_SETPAGESIZE, (WPARAM)s32Size, 0);
}

/*!
 * 获得滑块的快速步进值
 * @return  滑块的快速步进值
 * @param u32WndId 滑块的窗口id
 * @see
 */
int MINI_INTF_TrackBarGetLineSize(unsigned int u32WndId)
{
	return SendMessage (u32WndId, TBM_GETLINESIZE, 0, 0);
}




/*!
 * 设置滑块的位置
 * @param s32Pos 滑块的位置
 * @param u32WndId  滑块的窗口id
 * @see
 */
void MINI_INTF_TrackBarSetPos(unsigned int u32WndId, int s32Pos)
{
	SendMessage (u32WndId, TBM_SETPOS, (WPARAM)s32Pos, 0);
}


/*!
 * 获取滑块的位置
 * @return  滑块的位置
 * @param u32WndId 滑块的窗口id
 * @see
 */
int MINI_INTF_TrackBarGetPos(unsigned int u32WndId)
{
	return SendMessage (u32WndId, TBM_GETPOS, 0, 0);
}


/*!
 * 设置滑块的刻度间距，默认间距是 1。
 * @param s32Tickreq 滑块的刻度间距
 * @param u32WndId  滑块的窗口id
 * @see
 */
void MINI_INTF_TrackBarSetTickreq(unsigned int u32WndId, int s32Tickreq)
{
	SendMessage (u32WndId, TBM_SETTICKFREQ, (WPARAM)s32Tickreq, 0);
}


/*!
 * 获取滑块的刻度间距
 * @return  滑块的刻度间距
 * @param u32WndId 滑块的窗口id
 * @see
 */
int MINI_INTF_TrackBarGetTickreq(unsigned int u32WndId)
{
	return SendMessage (u32WndId, TBM_GETTICKFREQ, 0, 0);
}





/*!
 * 设置最小值及最大值处的文字说明
 * @param ps8MaxTip 最大处的说明
 * @param ps8MinTip 最小处的说明
 * @param u32WndId 窗口id
 * @see
 */
void MINI_INTF_TrackBarSetTip(unsigned int u32WndId, char *ps8MinTip, char *ps8MaxTip)
{
	SendMessage (u32WndId, TBM_SETTIP, (WPARAM)ps8MinTip, (LPARAM)ps8MaxTip);
}



/*!
 * 获取最小值及最大值处的文字说明
 * @param ps8MaxTip 最大处的说明
 * @param ps8MinTip 最小处的说明
 * @param u32WndId 窗口id
 * @see
 */
void MINI_INTF_TrackBarGetTip(unsigned int u32WndId, char *ps8MinTip, char *ps8MaxTip)
{
	SendMessage (u32WndId, TBM_GETTIP, (WPARAM)ps8MinTip, (LPARAM)ps8MaxTip);
}









/*!
 * 创建一个属性表
 * @return  返回创建的属性表窗口
 * @param s32Id 窗口的消息id
 * @param s32WinX 窗口的x坐标
 * @param s32WndHeight 窗口的高度
 * @param s32WndWidth 窗口的宽度
 * @param s32WndY 窗口的y坐标
 * @param u32ParentWnd 窗口的父窗口
 * @param u32Style 窗口的风格
 * @param u64AddDate 附加数据
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateWndPropSheet(DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;
	u32WndId = CreateWindow(CTRL_PROPSHEET,
							"",
							u32Style,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);


	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}

	return u32WndId;

}




/*!
 * 添加一个属性页
 * @return  新添加的属性页的索引
 * @param PageProc 属性页回调函数 不能为NULL
 * @param pstPageInfo 属性页的消息
 * @param u32WndId 属性表的窗口id
 * @see
 */
int MINI_INTF_PSM_AddPage(unsigned int u32WndId, DLGTEMPLATE *pstPageInfo,
							int (*PageProc)(HWND u32Dlg, int s32Message, WPARAM u32Param, LPARAM u64Param))
{
	return SendMessage (u32WndId, PSM_ADDPAGE,(WPARAM)pstPageInfo, (LPARAM)PageProc);
}

/*!
 * 删除属性页
 * @param s32Index 要删除的属性页的索引
 * @param u32WndId 属性表的窗口
 * @see
 */
void MINI_INTF_PSM_DelPage(unsigned int u32WndId, int s32Index)
{
	SendMessage(u32WndId, PSM_REMOVEPAGE, (WPARAM)s32Index, 0);
}


/*!
 * 通过属性页的索引获取属性页的窗口id，注意获取的是一个对话框的窗口id
 * @return  返回属性页的窗口id
 * @param s32Index 属性页的索引
 * @param u32WndId 属性表的窗口id
 * @see
 */
unsigned int MINI_INTF_PSM_GetPageWndIdByIndex(unsigned int u32WndId, int s32Index)
{
	return SendMessage (u32WndId, PSM_GETPAGE, s32Index, 0);
}

/*!
 * 获取属性页里面的控件的窗口id, 通过获取到的控件窗口id，可以像其它控件一样操作属性表里面的控件
 * @return  控件窗口id
 * @param s32Index 属性页的索引
 * @param u32Id 控件的id
 * @param u32WndId 属性表的窗口id
 * @see
 */
unsigned int MINI_INTF_PSM_GetPageCtrlWndId(unsigned int u32WndId, int s32Index, unsigned int u32Id)
{
	unsigned int u32Dlg = MINI_INTF_PSM_GetPageWndIdByIndex(u32WndId, s32Index);
	return GetDlgItem(u32Dlg, u32Id);
}


/*!
 * 返回属性页总个数
 * @return 返回属性页总个数
 * @param u32WndId 属性表的窗口id
 * @see
 */
unsigned int MINI_INTF_PSM_GetPageCount(unsigned int u32WndId)
{
	return SendMessage (u32WndId, PSM_GETPAGECOUNT, 0, 0);
}

/*!
 * 获取属性页标题栏的长度
 * @return  返回标题栏的长度
 * @param s32Index 属性页的索引
 * @param u32WndId 属性表的窗口id
 * @see
 */
int MINI_INTF_PSM_GetTitleLen(unsigned int u32WndId, int s32Index)
{
	return SendMessage (u32WndId, PSM_GETTITLELENGTH, (WPARAM)s32Index, 0);
}


/*!
 * 获取属性页的标题栏字符串
 * @param ps8Title 返回获取到的字符串
 * @param s32Index 属性页的索引
 * @param u32WndId 属性表的窗口id
 * @see
 */
void MINI_INTF_PSM_GetTitle(unsigned int u32WndId, int s32Index, char *ps8Title)
{
	SendMessage (u32WndId, PSM_GETTITLE, (WPARAM)s32Index, (LPARAM)ps8Title);
}


/*!
 * 设置属性页的标题栏
 * @param ps8Title 标题字符串
 * @param s32Index 属性页的索引
 * @param u32WndId 属性表的窗口id
 * @see
 */
void MINI_INTF_PSM_SetTitle(unsigned int u32WndId, int s32Index, char *ps8Title)
{
	SendMessage (u32WndId, PSM_SETTITLE, (WPARAM)s32Index, (LPARAM)ps8Title);
}



/*!
 * 获取当前显示的属性页的窗口id
 * @return  当前显示的属性页的窗口id
 * @param u32WndId 属性表的窗口id
 * @see
 */
unsigned int MINI_INTF_PSM_GetActivePage(unsigned int u32WndId)
{
	return SendMessage (u32WndId, PSM_GETACTIVEPAGE, 0, 0);
}

/*!
 * 获取当前显示的属性页的索引
 * @return  当前显示的属性页的索引
 * @param u32WndId 属性表的窗口id
 * @see
 */
int MINI_INTF_PSM_GetActiveIndex(unsigned int u32WndId)
{
	return SendMessage (u32WndId, PSM_GETACTIVEINDEX, 0, 0);
}

/*!
 * 通过索引设置当前显示的属性页
 * @param s32Index 要显示的属性页的索引
 * @param u32WndId 属性表的窗口id
 * @see
 */
void MINI_INTF_PSM_SetActiveByIndex(unsigned int u32WndId, int s32Index)
{
	SendMessage (u32WndId, PSM_SETACTIVEINDEX, (WPARAM)s32Index, 0);
}















/*!
 * 创建一个列表框
 * @return  返回列表框的窗口id
 * @param s32Id 列表框消息id
 * @param s32Type 列表框类型 1.单选列表框 2.多选列表框
 * @param s32WinX 窗口的x坐标
 * @param s32WndHeight 窗口的高度
 * @param s32WndWidth 窗口的宽度
 * @param s32WndY 窗口的y坐标
 * @param u32ParentWnd 窗口的父窗口
 * @param u32Style 窗口的风格
 * @param u64AddDate 附加数据
 * @param WndMsgProc 回调函数
 * @see
 */
unsigned int MINI_INTF_CreateWndListBox(int s32Type, DWORD u32Style,
									int s32Id,
									int s32WinX, int s32WndY, int s32WndWidth, int s32WndHeight,
									HWND u32ParentWnd, DWORD u64AddDate,
									void (* WndMsgProc)(HWND u32Wnd, int u32Id, int s32Param, DWORD u64AddData))
{
	unsigned int u32WndId;
	unsigned int u32TypeSwitch = 0;

	switch(s32Type) {
		case 1:
			u32TypeSwitch = 0;
			break;
		case 2:
			u32TypeSwitch = LBS_MULTIPLESEL;
			break;
		case 3:
			u32TypeSwitch = 0;
			//u32TypeSwitch = LBS_USEICON;
			//LBS_CHECKBOX
			break;
		default:
			u32TypeSwitch = 0;
			break;
	}

	u32WndId = CreateWindow(CTRL_LISTBOX,
							"",
							u32Style | u32TypeSwitch,
							s32Id,
							s32WinX,
							s32WndY,
							s32WndWidth,
							s32WndHeight,
							u32ParentWnd,
							u64AddDate);


	if(WndMsgProc) {
		SetNotificationCallback(u32WndId, WndMsgProc);
	}

	return u32WndId;

}





/*!
 * 为列表框添加一个条目
 * @return  返回添加的列表的条目
 * @param ps8String 要添加的列表显示的字符串
 * @param u32WndId 要添加的列表框
 * @see
 */
int MINI_INTF_LB_AddString(unsigned int u32WndId, char *ps8String)
{
	return SendMessage(u32WndId, LB_ADDSTRING, 0, (LPARAM)ps8String);
}



/*!
 * 为列表框添加一个条目
 * 		如果 index 等于 4，那么 string 将变为索引值为 4 的字符串――从顶头开始算起的第 5 个字符串（因为是从 0 开始
 * 		计数的），位于这个点后面的所有字符串都将向后推移。索引值为 -1 时，将字符串增加在最后。我们也可以对具有 LBS_SORT
 * 		风格的列表框使用 LB_INSERTSTRING，但是这时列表框将会忽略 index 的值，而根据排序的结果插入新的项。
 * @return 返回添加的列表的条目
 * @param ps8String 要添加的列表显示的字符串
 * @param s32Index 指定添加到哪个索引后面
 * @param u32WndId 要添加的列表框
 * @see
 */
int MINI_INTF_LB_InsertString(unsigned int u32WndId, int s32Index, char *ps8String)
{
	return SendMessage(u32WndId, LB_INSERTSTRING, (WPARAM)s32Index, (LPARAM)ps8String);
}


/*!
 * 删除列表框里面的一个列表项
 * @param s32Index 要删除列表项的所有
 * @param u32WndId 列表框的窗口id
 * @see
 */
void MINI_INTF_LB_DelString(unsigned int u32WndId, int s32Index)
{
	SendMessage(u32WndId, LB_DELETESTRING, (WPARAM)s32Index, 0);
}

/*!
 * 删除列表框所有的列表项
 * @param u32WndId 列表框的窗口id
 * @see
 */
void MINI_INTF_LB_ResetContent(unsigned int u32WndId)
{
	SendMessage(u32WndId, LB_RESETCONTENT, 0, 0);
}


/*!
 * 获取列表框的列表项的数量
 * @return  返回列表项的数量
 * @param u32WndId 要获取的列表项的窗口id
 * @see
 */
int MINI_INTF_LB_GetCount(unsigned int u32WndId)
{
	return SendMessage(u32WndId, LB_GETCOUNT, 0, 0);
}

/*!
 * 获取一个列表项的显示字符串的长度
 * @return  返回获取到的长度
 * @param s32Index 要获取的列表项的索引值
 * @param u32WndId 要获取的列表框的窗口id
 * @see
 */
int MINI_INTF_LB_GetTextLen(unsigned int u32WndId, int s32Index)
{
	return SendMessage(u32WndId, LB_GETTEXTLEN, (WPARAM)s32Index, 0);
}

/*!
 * 获取一个列表项的显示字符串
 * @return 返回获取到的字符串的长度
 * @param ps8Buf 存储获取到的字符串
 * @param s32Index 要获取的列表项的索引id
 * @param u32WndId 要获取的列表框的窗口id
 * @see
 */
int MINI_INTF_LB_GetText(unsigned int u32WndId, int s32Index, char *ps8Buf)
{
	return SendMessage(u32WndId, LB_GETTEXT, (WPARAM)s32Index, (LPARAM)ps8Buf);
}


/*!
 * 设置一个列表项的显示类容
 * @param ps8Buf 要设置的显示内容，字符串
 * @param s32Index 要设置的列表
 * @param u32WndId 要设置的列表框
 * @see
 */
void MINI_INTF_LB_SetText(unsigned int u32WndId, int s32Index, char *ps8Buf)
{
	SendMessage(u32WndId, LB_SETTEXT, (WPARAM)s32Index, (LPARAM)ps8Buf);
}


/*!
 * 设置一个列表项为选中状态
 * @param s32Index 要设置的列表项
 * @param u32WndId 要设置的列表框
 * @see
 */
void MINI_INTF_LB_SetCursel(unsigned int u32WndId, int s32Index)
{
	SendMessage(u32WndId, LB_SETCURSEL, (WPARAM)s32Index, 0);
}


/*!
 * 获取列表项当前选中的列表索引
 * @return  返回获取到的列表索引 没有条目被选中则返回 LB_ERR
 * @param u32WndId 要获取的列表框窗口id
 * @see
 */
int MINI_INTF_LB_GetCursel(unsigned int u32WndId)
{
	return SendMessage(u32WndId, LB_GETCURSEL, 0, 0);
}

/*!
 * 设置一个列表项为高亮，不会影响其他列表
 * @param bSwitch 1.高亮 0.取消高亮
 * @param s32Index 要设置的列表项
 * @param u32WndId 要设置的列表框
 * @see
 */
void MINI_INTF_LB_SetSel(unsigned int u32WndId, int s32Index, bool bSwitch)
{
	SendMessage(u32WndId, LB_SETSEL, (WPARAM)bSwitch, (LPARAM)s32Index);
}

/*!
 * 获取一个列表项是否为选择高亮
 * @return 0.没有选中 非0.选中
 * @param s32Index 要获取的列表项
 * @param u32WndId 列表框的窗口id
 * @see
 */
int MINI_INTF_LB_GetSel(unsigned int u32WndId, int s32Index)
{
	return SendMessage(u32WndId, LB_GETSEL, (WPARAM)s32Index, 0);
}






/*!
 * 查找含有字符串的条目
 * @return 返回模糊匹配字符串 ps8String 的条目索引值， LB_ERR 表示查找失败
 * @param ps8String 要查找的字符串
 * @param u32WndId 要查找的列表框
 * @see
 */
int MINI_INTF_LB_FindString(unsigned int u32WndId, char *ps8String)
{
	return SendMessage(u32WndId, LB_FINDSTRING, 0, (LPARAM)ps8String);
}


/*!
 * 获取列表项的状态
 * @return 返回由 index 指定索引处条目的检查框的状态。如果没有找到相应条目，则返回 LB_ERR。 CMFLAG_CHECKED 表示该条目的
 * 	检查框处于选择状态。 CMFLAG_PARTCHECKED 表示该条目的检查框处于部分选择状态。 CMFLAG_BLANK 表示该条目的检查框
 * 	处于未选择状态。
 * @param s32Index 要获取的列表项索引
 * @param u32WndId 要获取的列表框
 * @see
 */
int MINI_INTF_LB_GetCheckMark(unsigned int u32WndId, int s32Index)
{
	return SendMessage(u32WndId, LB_GETCHECKMARK, (WPARAM)s32Index, 0);
}


/*!
 * 设置由 s32Index 指定索引处条目的检查框的状态为加粗显示状态
 * @return 当没有找到 index 指定的条目时，返回 LB_ERR 表示失败，
 * 	否则根据 lParam 的值判断是否进行加粗设置，如果为 1 则加粗显示，为 0 则正常显示。
 * @param s32Index 要设置的列表项的索引
 * @param s32Status 要设置的列表项的加粗状态 1.加粗 0.正常显示
 * @param u32WndId 要设置的列表框的窗口id
 * @see
 */
int MINI_INTF_LB_SetItembold(unsigned int u32WndId, int s32Index, int s32Status)
{
	return SendMessage(u32WndId, LB_SETITEMBOLD, (WPARAM)s32Index, (LPARAM)s32Status);
}



int MINI_INTF_LB_GetItemDisable(unsigned int u32WndId, int s32Index)
{
	return SendMessage(u32WndId, LB_GETITEMDISABLE, (WPARAM)s32Index, 0);
}


int MINI_INTF_LB_SetItemDisable(unsigned int u32WndId, int s32Index, int s32Status)
{
	return SendMessage(u32WndId, LB_SETITEMDISABLE, (WPARAM)s32Index, s32Status);
}



/*

unsigned int MINI_INTF_CreateDlg(unsigned int u32ParentWnd, char *ps8MapPath, char* ps8Name)
{
	PBITMAP Bitmap;
	if(LoadBitmap(HDC_SCREEN, &Bitmap, ps8MapPath))
		return 1;
	DialogBoxIndirectParam (&DlgViewer, HWND_DESKTOP, ImageViewerProc, 0L);
	UnloadBitmap (&Bitmap);

}
*/




